import { defineStore } from 'pinia';
import axios from 'axios';
import { 
  getAllCloseLoopList,
  getCloseLoopDetailJb,
  getUserInfo,
  getCloseLoopDetailYz,
  getCloseLoopDetailYzBase,
  getCloseLoopDetailYzColumn,
  getCloseLoopDetail,
  getCloseLoopDetailNodes,
  getCloseLoopDetailColumn } from '@/api/api.js'; // 引入你的API封装

//获取闭环列表接口
export const useCloseLoopStore = defineStore('closeLoop', {
  state: () => ({
    closeLoopList: [], // 闭环列表数据
    selectedCloseLoopId: null, // 当前选中的闭环ID
    loading: false, // 数据加载状态
    error: null, // 错误信息
  }),

  actions: {
    // 获取闭环列表
    async fetchCloseLoopList() {
      this.loading = true;
      this.error = null;

      try {
        const result = await getAllCloseLoopList(); // 调用你的API
        if (result.code === 200) {
          // 直接使用后端返回的字段（假设后端返回的字段与前端一致）
          this.closeLoopList = result.data || [];
        } else {
          throw new Error(result.message || '数据格式不正确');
        }
      } catch (error) {
        this.error = error.message || '获取闭环列表失败';
        console.error('获取闭环列表失败:', error);
      } finally {
        this.loading = false;
      }
    },

    // 设置当前选中的闭环ID
    setSelectedCloseLoop(id) {
      this.selectedCloseLoopId = id;
    },

    // // 检测完整性（需后端接口支持）
    // async checkIntegrity(closeLoopId) {
    //   try {
    //     // 调用你的检测接口（如：await checkIntegrityAPI(closeLoopId)）
    //     // 更新本地状态（如标记检测结果）
    //   } catch (error) {
    //     this.error = error.message || '检测完整性失败';
    //   }
    // },

    // // 检测及时性（需后端接口支持）
    // async checkTimeliness(closeLoopId) {
    //   try {
    //     // 调用你的检测接口（如：await checkTimelinessAPI(closeLoopId)）
    //     // 更新本地状态（如标记检测结果）
    //   } catch (error) {
    //     this.error = error.message || '检测及时性失败';
    //   }
    // },

    // 重置状态
    reset() {
      this.closeLoopList = [];
      this.selectedCloseLoopId = null;
      this.error = null;
    },
  },
});

// 获取闭环基本信息接口
// stores/closeLoopList.js

export const closeLoopDetailJb = defineStore('closeLoopStoreJb', {
  state: () => ({
    closeLoopDetail: {
      CLOSE_LOOP_ID: '',
      USER_ID: '',
      REALNAME: '',
      CLOSE_LOOP_NAME: '',
      CLOSE_LOOP_DETAIL: ''
    },
    loading: false,
    error: null
  }),

  actions: {
    async getCloseLoopDetailJb(closeLoopId) {
      try {
        this.loading = true;
        const response = await getCloseLoopDetailJb({
          CLOSE_LOOP_ID: closeLoopId
        });
        if (response.code === 200) {
          this.closeLoopDetail = { ...response.data };
          return response.data;
        } else {
          throw new Error(response.message || '获取闭环基本信息失败');
        }
      } catch (error) {
        this.error = error.message;
        console.error('获取闭环基本信息失败:', error);
        throw error;
      } finally {
        this.loading = false;
      }
    }
  }
});

//获取闭环基本信息环主
export const useUserStore = defineStore('userStore', {
  state: () => ({
    userOptions: [], // 存储用户选项，格式：[{ value: '000292', label: '郑学军' }, ...]
    loading: false,
    error: null
  }),

  actions: {
    // 获取用户列表（用于下拉框）
    async fetchUserOptions(search = '') {
      try {
        this.loading = true;
        // 调用 getUserInfo API，并传递搜索参数（可选）
        const response = await getUserInfo({ search: search.trim() });
        
        if (response.code === 200) {
          // 解析数据：将 "USER_XX": "000292|郑学军" 转换为选项格式
          this.userOptions = response.data.map(item => {
            const [userId, realName] = item.USER_XX.split('|');
            return {
              value: userId,
              label: realName
            };
          });
          return this.userOptions;
        } else {
          throw new Error(response.message || '获取用户列表失败');
        }
      } catch (error) {
        this.error = error.message;
        console.error('获取用户列表失败:', error);
        throw error;
      } finally {
        this.loading = false;
      }
    }
  }
});



//获取主闭环的医嘱主要信息 
export const closeLoopDetailYz = defineStore('closeLoopStoreYz', {
  state: () => ({
    closeLoopDetail: {
      CLOSE_LOOP_ID: '',//闭环ID
      ADVICE_NAME: '',//医嘱名称
      VIEW_NAME: '',//医嘱视图名称
      HAVE_MANY_TIMES: '',//是否多次执行
      BASE_NAME: '',//数据源名称
      BASE_TABLE_NAME: '',//数据源表名称
      BASE_TABLE_ALIAS: '',//数据源表别名
      BASE_ID: '',//数据源ID
    },
    loading: false,
    error: null
  }),

  actions: {
    async getCloseLoopDetailYz(closeLoopId) { // 根据闭环ID获取闭环的医嘱主要信息
      this.loading = true; // 设置加载状态为true
      try {
        this.loading = true; //  设置loading状态为true
        const response = await getCloseLoopDetailYz({ //  调用getCloseLoopDetailYz方法，传入CLOSE_LOOP_ID参数
          CLOSE_LOOP_ID: closeLoopId
        });
        if (response.code === 200) { //  如果返回的code为200，则将返回的数据赋值给closeLoopDetail
          this.closeLoopDetail = { ...response.data };
          return response.data; //  返回数据
        } else {
          throw new Error(response.message || '获取主闭环的医嘱主要信息 '); //  否则抛出错误，错误信息为返回的消息或者默认的错误信息
        }
      } catch (error) {
        this.error = error.message;
        console.error('获取主闭环的医嘱主要信息失败 :', error); //  打印错误信息
        throw error; //  抛出错误
      } finally {
        this.loading = false; //  最后将loading状态设置为false
      }
    }
  }
});

//获取主闭环数据源下拉框数据
export const closeLoopDetailYzBase = defineStore('closeLoopBaseStore', {
  state: () => ({
    closeLoopBaseList: [], // 闭环下拉框数据
    loading: false, // 数据加载状态
    error: null // 错误信息
  }),

  actions: {
    async fetchCloseLoopBaseList() { // 获取闭环下拉框数据的方法
      try {
        this.loading = true; // 设置loading状态为true
        const response = await getCloseLoopDetailYzBase(); // 调用getCloseLoopDetailYzBase方法获取数据
        if (response.code === 200) { // 如果返回的code为200，则将返回的数据赋值给closeLoopBaseList
          this.closeLoopBaseList = response.data || []; // 如果没有数据，则赋值为空数组
        } else {
          throw new Error(response.message || '获取闭环下拉框数据失败'); // 否则抛出错误，错误信息为返回的消息或者默认的错误信息
        }
      } catch (error) {
        this.error = error.message; // 设置错误信息
        console.error('获取数据源下拉数据失败:', error); // 打印错误信息
      } finally {
        this.loading = false; // 最后将loading状态设置为false
      }
    }
  }
})

//获取闭环的医嘱字段配置列表
export const closeLoopDetailYzColumn = defineStore('closeLoopBaseColumnStore', {
  state: () => ({
    // 字段配置列表（数组）
    closeLoopBaseColumnList: [],
    // 单条字段配置（如果需要）
    //closeLoopColumnDetail: {},
    loading: false,
    error: null
  }),

  actions: {
    // 获取字段配置列表（返回数组）
    async getCloseLoopBaseColumnList(closeLoopId) {
      this.loading = true;
      try {
        const response = await getCloseLoopDetailYzColumn({
          CLOSE_LOOP_ID: closeLoopId
        });
        if (response.code === 200) {
          this.closeLoopBaseColumnList = response.data; // 存储数组
          return this.closeLoopBaseColumnList;
        } else {
          throw new Error(response.message || '获取字段配置列表失败');
        }
      } catch (error) {
        this.error = error.message;
        console.error('获取字段配置列表失败:', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },
  }
});


//获取闭环的节点列表
export const closeLoopDetail = defineStore('getCloseLoopDeatilStore', { // 注意：保持你的 store 名称
  state: () => ({
    closeLoopDeatilList: [],
    loading: false,
    error: null,
    cancelTokenSource: null // 用于取消请求
  }),

  actions: {
    async getCloseLoopDeatilList(closeLoopId) {
      this.loading = true;
      this.cancelTokenSource = axios.CancelToken.source(); // 生成新的CancelToken

      try {
        // 调用封装的API函数，并传递参数和CancelToken
        const response = await getCloseLoopDetail({
           CLOSE_LOOP_ID: closeLoopId // 传递参数
        });

        // 处理API响应（假设返回结构包含code和data）
        if (response.code === 200) {
          this.closeLoopDeatilList = response.data;
          this.error = null;
        } else {
          throw new Error(response.message || '获取数据失败');
        }
      } catch (error) {
        this.error = error.message;
        console.error('获取闭环的节点列表失败:', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },
  }
});
//获取闭环的节点列表的字段配置
export const closeLoopDetailNodes = defineStore('getCloseLoopDeatiNodesStore', { // 注意：保持你的 store 名称
  state: () => ({
    closeLoopDetailNodesList: [],
    loading: false,
    error: null,
  }),

  actions: {
    async getCloseLoopDetailNodes(NODE_ID) {
      this.loading = true;

      try {
        // 调用封装的API函数，并传递参数和CancelToken
        const response = await getCloseLoopDetailNodes({
          NODE_ID: NODE_ID // 传递参数
        });

        // 处理API响应（假设返回结构包含code和data）
        if (response.code === 200) {
          this.getCloseLoopDeatilNodes = response.data;
          this.error = null;
        } else {
          throw new Error(response.message || '获取数据失败');
        }
      } catch (error) {
        this.error = error.message;
        console.error('获取闭环的节点列表的字段配置失败:', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },
  }
});
//获取闭环的节点列表的字段配置
export const closeLoopDetailCloumn = defineStore('getCloseLoopDetaiCloumnStore', { // 注意：保持你的 store 名称
  state: () => ({
    closeLoopDetailColumnList: [],
    loading: false,
    error: null,
  }),

  actions: {
    async getCloseLoopDetailList(NODE_ID) {
      this.loading = true;

      try {
        // 调用封装的API函数，并传递参数和CancelToken
        const response = await getCloseLoopDetailColumn({
          NODE_ID: NODE_ID // 传递参数
        });

        // 处理API响应（假设返回结构包含code和data）
        if (response.code === 200) {
          this.closeLoopDetailColumnList = response.data;
          this.error = null;
        } else {
          throw new Error(response.message || '获取数据失败');
        }
      } catch (error) {
        this.error = error.message;
        console.error('获取闭环的节点列表的字段配置失败:', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },
  }
});
